.TH std::any 3 "2024.06.10" "http://cppreference.com" "C++ Standard Libary"
.SH NAME
std::any \- std::any

.SH Synopsis
   Defined in header <any>
   class any;               \fI(since C++17)\fP

   The class any describes a type-safe container for single values of any copy
   constructible type.

   1) An object of class any stores an instance of any type that satisfies the
   constructor requirements or is empty, and this is referred to as the state of the
   class any object. The stored instance is called the contained object. Two states are
   equivalent if they are either both empty or if both are not empty and if the
   contained objects are equivalent.
   2) The non-member any_cast functions provide type-safe access to the contained
   object.

   Implementations are encouraged to avoid dynamic allocations for small objects, but
   such an optimization may only be applied to types for which
   std::is_nothrow_move_constructible returns true.

.SH Member functions

   constructor   constructs an any object
                 \fI(public member function)\fP
   operator=     assigns an any object
                 \fI(public member function)\fP
   destructor    destroys an any object
                 \fI(public member function)\fP
.SH Modifiers
   emplace       change the contained object, constructing the new object directly
                 \fI(public member function)\fP
   reset         destroys contained object
                 \fI(public member function)\fP
   swap          swaps two any objects
                 \fI(public member function)\fP
.SH Observers
   has_value     checks if object holds a value
                 \fI(public member function)\fP
   type          returns the typeid of the contained value
                 \fI(public member function)\fP

.SH Non-member functions

   std::swap(std::any) specializes the std::swap algorithm
   \fI(C++17)\fP             \fI(function)\fP
   any_cast            type-safe access to the contained object
   \fI(C++17)\fP             \fI(function template)\fP
   make_any            creates an any object
   \fI(C++17)\fP             \fI(function template)\fP

.SH Helper classes

   bad_any_cast exception thrown by the value-returning forms of any_cast on a type
   \fI(C++17)\fP      mismatch
                \fI(class)\fP

.SH Notes

   Feature-test macro  Value    Std   Feature
   __cpp_lib_any      201606L \fI(C++17)\fP std::any

.SH Example


// Run this code

 #include <any>
 #include <iostream>

 int main()
 {
     std::cout << std::boolalpha;

     // any type
     std::any a = 1;
     std::cout << a.type().name() << ": " << std::any_cast<int>(a) << '\\n';
     a = 3.14;
     std::cout << a.type().name() << ": " << std::any_cast<double>(a) << '\\n';
     a = true;
     std::cout << a.type().name() << ": " << std::any_cast<bool>(a) << '\\n';

     // bad cast
     try
     {
         a = 1;
         std::cout << std::any_cast<float>(a) << '\\n';
     }
     catch (const std::bad_any_cast& e)
     {
         std::cout << e.what() << '\\n';
     }

     // has value
     a = 2;
     if (a.has_value())
         std::cout << a.type().name() << ": " << std::any_cast<int>(a) << '\\n';

     // reset
     a.reset();
     if (!a.has_value())
         std::cout << "no value\\n";

     // pointer to contained data
     a = 3;
     int* i = std::any_cast<int>(&a);
     std::cout << *i << '\\n';
 }

.SH Possible output:

 int: 1
 double: 3.14
 bool: true
 bad any_cast
 int: 2
 no value
 3

.SH See also

   function           wraps callable object of any copy constructible type with
   \fI(C++11)\fP            specified function call signature
                      \fI(class template)\fP
   move_only_function wraps callable object of any type with specified function call
   (C++23)            signature
                      \fI(class template)\fP
   variant            a type-safe discriminated union
   \fI(C++17)\fP            \fI(class template)\fP
   optional           a wrapper that may or may not hold an object
   \fI(C++17)\fP            \fI(class template)\fP
